home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / C Internet Config / IC Libraries ƒ / IC Resource ƒ / Syslog Component ƒ / syslog.c < prev    next >
Encoding:
Text File  |  1995-11-15  |  9.7 KB  |  319 lines  |  [TEXT/SPM ]
  1. nfo)
  2.  
  3. #else
  4. typedef pascal void (*ExitToShellUPP)(void);
  5.  
  6. #define NewExitToShellProc(routine) (ExitToShellUPP)(routine)
  7. #define CallExitToShellProc(routine) (*(routine))()
  8.  
  9. #endif
  10.  
  11. #define DisposeExitToShellProc(routine) DisposeRoutineDescriptor((UniversalProcPtr)routine)
  12.  
  13. static ExitToShellUPP _gSyslog_oldETS;
  14. static ExitToShellUPP _gSyslog_newETS;
  15. static long _gSyslog_A5;
  16.  
  17. pascal void SyslogAtExit(void);
  18. pascal void SyslogAtExit(void){
  19.     
  20. #if defined(powerc)||defined(__powerc)
  21. #else
  22.     // 68k code
  23.     SetA5(_gSyslog_A5);
  24. #endif
  25.     
  26.     // if we get here then the component has been opened and it needs closed
  27.     DisposePtr((Ptr)_gSyslogBuf);
  28.     CloseComponent(_gSyslogComponent);
  29.     
  30.     DisposeRoutineDescriptor(_gSyslog_newETS);
  31.     
  32.     CallExitToShellProc(_gSyslog_oldETS);
  33.     return;
  34. }
  35.  
  36. /*
  37.     SyslogInit
  38.     
  39.     Initialize the internal syslog glue.  Also inserts a ETS patch to ensure that the
  40.     component gets closed when the app is quitting.
  41. */
  42. void SyslogInit(void){
  43.     Component theComp;
  44.     ComponentDescription desc;
  45.     
  46.     if (!HaveComponentMgr())
  47.         return;
  48.     
  49.     if (_gSyslogComponent!=(ComponentInstance)0)
  50.         return; // already initialized
  51.     
  52.     _gSyslogBuf=(char*)NewPtr(4096*2); // allocate an 8k buffer
  53.     
  54.     if (_gSyslogBuf==(char*)0)
  55.         return;
  56.     
  57.     
  58.     desc.componentType=ksyslogComponentType;
  59.     desc.componentSubType=kAnyComponentType;
  60.     desc.componentManufacturer=kAnyComponentType;
  61.     desc.componentFlags=kAnyComponentType;
  62.     desc.componentFlagsMask=kAnyComponentType;
  63.     
  64.     theComp=FindNextComponent((Component)0,&desc);
  65.     
  66.     if (theComp!=(Component)0){
  67.         
  68.         _gSyslogComponent=OpenComponent(theComp);
  69.         
  70.         if (_gSyslogComponent==(ComponentInstance)0){
  71.             DisposePtr((Ptr)_gSyslogBuf);
  72.             return;
  73.         }
  74.         
  75.         _gSyslog_newETS=NewExitToShellProc(SyslogAtExit);
  76.         
  77. #if defined(powerc)||defined(__powerc)
  78.         // nothing special here
  79. #else
  80.         // 68k code
  81.         _gSyslog_A5=SetCurrentA5();
  82. #endif
  83.         
  84.         // have the component, and it is open.  Install the ETS patch
  85.         _gSyslog_oldETS=(ExitToShellUPP)NGetTrapAddress(_ExitToShell,ToolTrap);
  86.         NSetTrapAddress((UniversalProcPtr)_gSyslog_newETS,_ExitToShell,ToolTrap);
  87.         
  88.     } else {
  89.         // couldn't find the component
  90.         DisposePtr((Ptr)_gSyslogBuf);
  91.     }
  92.     
  93.     return;
  94. }
  95.  
  96.  
  97. #if defined(powerc) || defined(__powerc)
  98.  
  99. enum {
  100.     uppCallComponentProcInfo = kPascalStackBased
  101.         | RESULT_SIZE(kFourByteCode)
  102.         | STACK_ROUTINE_PARAMETER(1, kFourByteCode)
  103. };
  104.  
  105. /* A few macros to simplify the code (or does it make it more complex?  ;-) */
  106. #define CallComponentGlue(ptr) \
  107.     CallUniversalProc(CallComponentUPP,uppCallComponentProcInfo,(ptr))
  108.  
  109. #define PPC_Glue(parmsType) \
  110.     unsigned char flags; \
  111.     unsigned char size; \
  112.     short what; \
  113.     parmsType parms; \
  114.     ComponentInstance inst
  115.  
  116. #define SetupGlue(var,sel,type,ic)\
  117.     (var).flags=0;\
  118.     (var).size=sizeof(type);\
  119.     (var).what=(sel);\
  120.     (var).inst=(ic)
  121.  
  122. #define PPC_VoidGlue \
  123.     unsigned char flags; \
  124.     unsigned char size; \
  125.     short what; \
  126.     ComponentInstance inst
  127.  
  128. #define SetupVoidGlue(var,sel,ic)\
  129.     (var).flags=0;\
  130.     (var).size=0;\
  131.     (var).what=(sel);\
  132.     (var).inst=(ic)
  133.  
  134. #define SetGlueParm(var,ps,val) \
  135.     (var).parms.ps=(val)
  136.  
  137. pascal ComponentResult Comp_setlogmask(ComponentInstance inst,short maskpri){
  138.     ComponentResult err;
  139.     
  140.     #pragma options align=mac68k
  141.     // Remember that these must be in reverse order from the parameters
  142.     struct GlueParms {
  143.         short maskpri;
  144.     };
  145.     
  146.     typedef struct GlueParms GlueParms;
  147.     
  148.     struct ICCallGlue {
  149.         PPC_Glue(GlueParms);
  150.     };
  151.     
  152.     typedef struct ICCallGlue ICCallGlue;
  153.     #pragma options align=reset
  154.     
  155.     ICCallGlue glue;
  156.     
  157.     if (inst == (ComponentInstance)0) {
  158.         err = badComponentInstance;
  159.     } else {
  160.         // only one for the glue struct
  161.         SetupGlue(glue,ksetlogmaskSelector,GlueParms,inst);
  162.         // the glue struct, the selector code, the parameter struct, and the instance
  163.         
  164.         // one of these for each parameter
  165.         SetGlueParm(glue,maskpri,maskpri);
  166.         // the glue struct, the parameter struct item to set, and the function parameter to use
  167.         
  168.         // call the component now
  169.         err = CallComponentGlue(&glue);
  170.     }
  171.     
  172.     return err; // return the error
  173. }
  174.  
  175. pascal ComponentResult Comp_geterror(ComponentInstance inst,OSErr* errp){
  176.     ComponentResult err;
  177.     
  178.     #pragma options align=mac68k
  179.     struct GlueParms {
  180.         OSErr* errp;
  181.     };
  182.     typedef struct GlueParms GlueParms;
  183.     struct ICCallGlue {
  184.         PPC_Glue(GlueParms);
  185.     };
  186.     typedef struct ICCallGlue ICCallGlue;
  187.     #pragma options align=reset
  188.     
  189.     ICCallGlue glue;
  190.     
  191.     if (inst == (ComponentInstance)0) {
  192.         err = badComponentInstance;
  193.     } else {
  194.         SetupGlue(glue,kGetErrorSelector,GlueParms,inst);
  195.         
  196.         SetGlueParm(glue,errp,errp);
  197.         
  198.         err = CallComponentGlue(&glue);
  199.     }
  200.     return err;
  201. }
  202.  
  203. pascal ComponentResult Comp_openlog(ComponentInstance inst,const char* ident,
  204.         long logopt,short facility){
  205.     ComponentResult err;
  206.     
  207.     #pragma options align=mac68k
  208.     struct GlueParms {
  209.         short facility;
  210.         long logopt;
  211.         const char* ident;
  212.     };
  213.     typedef struct GlueParms GlueParms;
  214.     struct ICCallGlue {
  215.         PPC_Glue(GlueParms);
  216.     };
  217.     typedef struct ICCallGlue ICCallGlue;
  218.     #pragma options align=reset
  219.     
  220.     ICCallGlue glue;
  221.     
  222.     if (inst == (ComponentInstance)0) {
  223.         err = badComponentInstance;
  224.     } else {
  225.         SetupGlue(glue,kopenlogSelector,GlueParms,inst);
  226.         
  227.         SetGlueParm(glue,ident,ident);
  228.         SetGlueParm(glue,logopt,logopt);
  229.         SetGlueParm(glue,facility,facility);
  230.         
  231.         err = CallComponentGlue(&glue);
  232.     }
  233.     return err;
  234. }
  235.  
  236. pascal ComponentResult Comp_syslog(ComponentInstance inst,short priority,
  237.         const char* message){
  238.     ComponentResult err;
  239.     
  240.     #pragma options align=mac68k
  241.     struct GlueParms {
  242.         const char* message;
  243.         short priority;
  244.     };
  245.     typedef struct GlueParms GlueParms;
  246.     struct ICCallGlue {
  247.         PPC_Glue(GlueParms);
  248.     };
  249.     typedef struct ICCallGlue ICCallGlue;
  250.     #pragma options align=reset
  251.     
  252.     ICCallGlue glue;
  253.     
  254.     if (inst == (ComponentInstance)0) {
  255.         err = badComponentInstance;
  256.     } else {
  257.         SetupGlue(glue,ksyslogSelector,GlueParms,inst);
  258.         
  259.         SetGlueParm(glue,message,message);
  260.         SetGlueParm(glue,priority,priority);
  261.         
  262.         err = CallComponentGlue(&glue);
  263.     }
  264.     return err;
  265. }
  266.  
  267. pascal ComponentResult Comp_closelog(ComponentInstance inst){
  268.     ComponentResult err;
  269.     
  270.     #pragma options align=mac68k
  271.     struct ICCallGlue {
  272.         PPC_VoidGlue;
  273.     };
  274.     typedef struct ICCallGlue ICCallGlue;
  275.     #pragma options align=reset
  276.     
  277.     ICCallGlue glue;
  278.     
  279.     if (inst == (ComponentInstance)0) {
  280.         err = badComponentInstance;
  281.     } else {
  282.         SetupVoidGlue(glue,kcloselogSelector,inst);
  283.         
  284.         err = CallComponentGlue(&glue);
  285.     }
  286.     return err;
  287. }
  288.  
  289. pascal ComponentResult Comp_setfile(ComponentInstance inst,FSSpecPtr spec){
  290.     ComponentResult err;
  291.     
  292.     #pragma options align=mac68k
  293.     struct GlueParms {
  294.         FSSpecPtr spec;
  295.     };
  296.     typedef struct GlueParms GlueParms;
  297.     struct ICCallGlue {
  298.         PPC_Glue(GlueParms);
  299.     };
  300.     typedef struct ICCallGlue ICCallGlue;
  301.     #pragma options align=reset
  302.     
  303.     ICCallGlue glue;
  304.     
  305.     if (inst == (ComponentInstance)0) {
  306.         err = badComponentInstance;
  307.     } else {
  308.         SetupGlue(glue,kSetFileSelector,GlueParms,inst);
  309.         
  310.         SetGlueParm(glue,spec,spec);
  311.         
  312.         err = CallComponentGlue(&glue);
  313.     }
  314.     return err;
  315. }
  316.  
  317. #endif
  318.  
  319.